package com.team2.hospital.controller;

import com.team2.hospital.entity.Admin;
import com.team2.hospital.entity.Doctor;
import com.team2.hospital.entity.Orders;
import com.team2.hospital.service.AdminService;
import com.team2.hospital.service.DoctorService;
import com.team2.hospital.service.OrderService;
import com.team2.hospital.service.PatientService;
import com.team2.hospital.utils.JwtUtil;
import com.team2.hospital.utils.ResponseData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;


@RestController
@RequestMapping("admin")
public class AdminController {

    @Autowired
    private AdminService adminService;
    @Autowired
    private DoctorService doctorService;
    @Autowired
    private PatientService patientService;
    @Autowired
    private OrderService orderService;

    /**
     * 登录数据验证
     *
     * @param aId       管理员账号
     * @param aPassword 管理员密码
     * @return 返回登录结果
     */
    @PostMapping("/login")
    @ResponseBody
    public ResponseData login(@RequestParam("aId") int aId, @RequestParam("aPassword") String aPassword) {
        Admin admin = this.adminService.login(aId, aPassword);
        if (admin != null) {
            Map<String, String> map = new HashMap<>();
            map.put("aName", admin.getAName());
            map.put("aId", String.valueOf(admin.getAId()));
            String token = JwtUtil.getToken(map);
            map.put("token", token);
            return ResponseData.success("登录成功", map);
        } else {
            return ResponseData.fail("登录失败，密码或账号错误");
        }
    }

    /**
     * 分页模糊查询所有医护人员信息
     *
     * @param pageNumber 页码
     * @param size       页面大小
     * @param query      查询条件
     */
    @RequestMapping("findAllDoctors")
    public ResponseData findAllDoctors(@RequestParam(value = "pageNumber") int pageNumber, @RequestParam(value = "size") int size, @RequestParam(value = "query") String query) {
        return ResponseData.success("返回医护人员信息成功", this.doctorService.findAllDoctors(pageNumber, size, query));
    }

    /**
     * 根据id查找医生
     *
     * @param dId 医生id
     * @return 医生信息
     */
    @RequestMapping("findDoctor")
    public ResponseData findDoctor(@RequestParam(value = "dId") int dId) {
        return ResponseData.success("查询医生成功", this.doctorService.findDoctor(dId));
    }

    /**
     * 增加医生信息
     *
     * @param doctor 医生信息
     * @return 增加结果
     */
    @RequestMapping("addDoctor")
    @ResponseBody
    public ResponseData addDoctor(Doctor doctor) {
        Boolean bo = this.doctorService.addDoctor(doctor);
        if (bo) {
            return ResponseData.success("增加医生信息成功");
        }
        return ResponseData.fail("增加医生信息失败！账号或已被占用");
    }

    /**
     * 删除医生信息
     *
     * @param dId 医生id
     * @return 删除结果
     */
    @RequestMapping("deleteDoctor")
    public ResponseData deleteDoctor(@RequestParam(value = "dId") int dId) {
        Boolean bo = this.doctorService.deleteDoctor(dId);
        if (bo) {
            return ResponseData.success("删除医生信息成功");
        }
        return ResponseData.fail("删除医生信息失败");
    }

    /**
     * 修改医生信息
     *
     * @param doctor 医生信息
     * @return 修改结果
     */
    @RequestMapping("modifyDoctor")
    @ResponseBody
    public ResponseData modifyDoctor(Doctor doctor) {
        this.doctorService.modifyDoctor(doctor);
        return ResponseData.success("修改医生信息成功");
    }

    /**
     * 分页模糊查询所有患者信息
     *
     * @param pageNumber 页码
     * @param size       页面大小
     * @param query      查询条件
     * @return 患者信息
     */
    @RequestMapping("findAllPatients")
    public ResponseData findAllPatients(@RequestParam(value = "pageNumber") int pageNumber, @RequestParam(value = "size") int size, @RequestParam(value = "query") String query) {
        return ResponseData.success("返回患者信息成功", this.patientService.findAllPatients(pageNumber, size, query));
    }

    /**
     * 删除患者信息
     *
     * @param pId 患者id
     * @return 删除结果
     */
    @RequestMapping("deletePatient")
    public ResponseData deletePatient(@RequestParam(value = "pId") int pId) {
        Boolean bo = this.patientService.deletePatient(pId);
        if (bo) {
            return ResponseData.success("删除患者信息成功");
        }
        return ResponseData.fail("删除患者信息失败");
    }

    /**
     * 分页模糊查询所有挂号信息
     *
     * @param pageNumber 页码
     * @param size       页面大小
     * @param query      查询条件
     * @return 挂号信息
     */
    @RequestMapping("findAllOrders")
    public ResponseData findAllOrders(@RequestParam(value = "pageNumber") int pageNumber, @RequestParam(value = "size") int size, @RequestParam(value = "query") String query) {
        return ResponseData.success("返回挂号信息成功", this.orderService.findAllOrders(pageNumber, size, query));
    }

    /**
     * 删除挂号信息
     *
     * @param oId 挂号id
     * @return 删除结果
     */
    @RequestMapping("deleteOrder")
    public ResponseData deleteOrder(@RequestParam(value = "oId") int oId) {
        Boolean bo = this.orderService.deleteOrder(oId);
        if (bo) {
            return ResponseData.success("删除挂号信息成功");
        }
        return ResponseData.fail("删除挂号信息失败");
    }

    /**
     * 增加挂号信息
     *
     * @param order 挂号信息
     * @param arId  挂号科室id
     * @return 增加结果
     */
    @RequestMapping("adminAddOrder")  // 映射到 adminAddOrder 请求
    @ResponseBody  // 返回 JSON 格式数据
    public ResponseData adminAddOrder(Orders order, String arId) {
        System.out.println("[adminAddOrder] 请求开始，时间：" + System.currentTimeMillis() + "，arId：" + arId + "，order：" + order);
        // 调用 orderService 中的 adminAddOrder 方法处理挂号信息
        if (this.orderService.adminAddOrder(order, arId))
            return ResponseData.success("插入挂号信息成功");  // 返回成功的响应
        return ResponseData.fail("插入挂号信息失败");  // 返回失败的响应
    }

    /**
     * 获取挂号信息（诊疗）
     *
     * @param pageNumber 当前页码
     * @param size       每页大小
     * @param query      查询条件
     * @return 返回查询结果
     */
    @RequestMapping("findDisOrders")  // 映射到 findDisOrders 请求
    public ResponseData findDisOrders(@RequestParam(value = "pageNumber") int pageNumber,
                                      @RequestParam(value = "size") int size,
                                      @RequestParam(value = "query") String query) {
        System.out.println("[findDisOrders] 请求开始，时间：" + System.currentTimeMillis() + "，pageNumber：" + pageNumber + "，size：" + size + "，query：" + query);
        // 调用 orderService 中的 findDisOrders 方法返回诊疗挂号信息
        return ResponseData.success("返回挂号信息成功", this.orderService.findDisOrders(pageNumber, size, query));
    }

    /**
     * 获取挂号信息（治疗）
     *
     * @param pageNumber 当前页码
     * @param size       每页大小
     * @param query      查询条件
     * @return 返回查询结果
     */
    @RequestMapping("findTreatOrders")  // 映射到 findTreatOrders 请求
    public ResponseData findTreatOrders(@RequestParam(value = "pageNumber") int pageNumber,
                                        @RequestParam(value = "size") int size,
                                        @RequestParam(value = "query") String query) {
        System.out.println("[findTreatOrders] 请求开始，时间：" + System.currentTimeMillis() + "，pageNumber：" + pageNumber + "，size：" + size + "，query：" + query);
        // 调用 orderService 中的 findTreatOrders 方法返回治疗挂号信息
        return ResponseData.success("返回挂号信息成功", this.orderService.findTreatOrders(pageNumber, size, query));
    }

    /**
     * 获取挂号信息（检查）
     *
     * @param pageNumber 当前页码
     * @param size       每页大小
     * @param query      查询条件
     * @return 返回查询结果
     */
    @RequestMapping("findCheckOrders")  // 映射到 findCheckOrders 请求
    public ResponseData findCheckOrders(@RequestParam(value = "pageNumber") int pageNumber,
                                        @RequestParam(value = "size") int size,
                                        @RequestParam(value = "query") String query) {
        System.out.println("[findCheckOrders] 请求开始，时间：" + System.currentTimeMillis() + "，pageNumber：" + pageNumber + "，size：" + size + "，query：" + query);
        // 调用 orderService 中的 findCheckOrders 方法返回检查挂号信息
        return ResponseData.success("返回挂号信息成功", this.orderService.findCheckOrders(pageNumber, size, query));
    }

    /**
     * 获取挂号信息（退号）
     *
     * @param pageNumber 当前页码
     * @param size       每页大小
     * @param query      查询条件
     * @return 返回查询结果
     */
    @RequestMapping("findReturnOrders")  // 映射到 findReturnOrders 请求
    public ResponseData findReturnOrders(@RequestParam(value = "pageNumber") int pageNumber,
                                         @RequestParam(value = "size") int size,
                                         @RequestParam(value = "query") String query) {
        System.out.println("[findReturnOrders] 请求开始，时间：" + System.currentTimeMillis() + "，pageNumber：" + pageNumber + "，size：" + size + "，query：" + query);
        // 调用 orderService 中的 findReturnOrders 方法返回退号挂号信息
        return ResponseData.success("返回挂号信息成功", this.orderService.findReturnOrders(pageNumber, size, query));
    }


    /**
     * 配药操作
     *
     * @param oId 挂号订单 ID
     * @return 配药结果
     */
    @RequestMapping("changeDis")
    public ResponseData changeDis(@RequestParam(value = "oId") int oId) {
        System.out.println("[changeDis] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 changeDis 方法进行配药操作
        Boolean bo = this.orderService.changeDis(oId);
        if (bo) {
            return ResponseData.success("配药成功");  // 返回配药成功的响应
        }
        return ResponseData.fail("配药失败");  // 返回配药失败的响应
    }

    /**
     * 审核操作
     *
     * @param oId 挂号订单 ID
     * @return 审核结果
     */
    @RequestMapping("changeCheck")
    public ResponseData changeCheck(@RequestParam(value = "oId") int oId) {
        System.out.println("[changeCheck] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 changeCheck 方法进行审核操作
        Boolean bo = this.orderService.changeCheck(oId);
        if (bo) {
            return ResponseData.success("审核成功");  // 返回审核成功的响应
        }
        return ResponseData.fail("审核失败");  // 返回审核失败的响应
    }

    /**
     * 治疗操作
     *
     * @param oId 挂号订单 ID
     * @return 治疗结果
     */
    @RequestMapping("changeTreat")
    public ResponseData changeTreat(@RequestParam(value = "oId") int oId) {
        System.out.println("[changeTreat] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 changeTreat 方法进行治疗操作
        Boolean bo = this.orderService.changeTreat(oId);
        if (bo) {
            return ResponseData.success("治疗成功");  // 返回治疗成功的响应
        }
        return ResponseData.fail("治疗失败");  // 返回治疗失败的响应
    }

    /**
     * 检查退费操作
     *
     * @param oId 挂号订单 ID
     * @return 检查退费结果
     */
    @RequestMapping("changeRTreat")
    public ResponseData changeRTreat(@RequestParam(value = "oId") int oId) {
        System.out.println("[changeRTreat] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 changeRTreat 方法进行检查退费操作
        Boolean bo = this.orderService.changeRTreat(oId);
        if (bo) {
            return ResponseData.success("检查退费成功");  // 返回检查退费成功的响应
        }
        return ResponseData.fail("检查退费失败");  // 返回检查退费失败的响应
    }

    /**
     * 药物退费操作
     *
     * @param oId 挂号订单 ID
     * @return 药物退费结果
     */
    @RequestMapping("changeRDrug")
    public ResponseData changeRDrug(@RequestParam(value = "oId") int oId) {
        System.out.println("[changeRDrug] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 changeRDrug 方法进行药物退费操作
        Boolean bo = this.orderService.changeRDrug(oId);
        if (bo) {
            return ResponseData.success("药物退费成功");  // 返回药物退费成功的响应
        }
        return ResponseData.fail("药物退费失败");  // 返回药物退费失败的响应
    }

    /**
     * 药物退费操作（检查药物）
     *
     * @param oId 挂号订单 ID
     * @return 药物退费结果
     */
    @RequestMapping("changeRCheckDrug")
    public ResponseData changeRCheckDrug(@RequestParam(value = "oId") int oId) {
        System.out.println("[changeRCheckDrug] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 changeRCheckDrug 方法进行药物退费操作（检查药物）
        Boolean bo = this.orderService.changeRCheckDrug(oId);
        if (bo) {
            return ResponseData.success("药物退费成功");  // 返回药物退费成功的响应
        }
        return ResponseData.fail("药物退费失败");  // 返回药物退费失败的响应
    }

    /**
     * 支付治疗费用操作
     *
     * @param oId 挂号订单 ID
     * @return 支付结果
     */
    @RequestMapping("payTreat")
    public ResponseData payTreat(@RequestParam(value = "oId") int oId) {
        System.out.println("[payTreat] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 payTreat 方法进行治疗费用支付操作
        Boolean bo = this.orderService.payTreat(oId);
        if (bo) {
            return ResponseData.success("治疗费用支付成功");  // 返回治疗费用支付成功的响应
        }
        return ResponseData.fail("治疗费用支付失败");  // 返回治疗费用支付失败的响应
    }

    /**
     * 支付挂号费用操作
     *
     * @param oId 挂号订单 ID
     * @return 支付结果
     */
    @RequestMapping("payRegi")
    public ResponseData payRegi(@RequestParam(value = "oId") int oId) {
        System.out.println("[payRegi] 请求开始，时间：" + System.currentTimeMillis() + "，oId：" + oId);
        // 调用 orderService 中的 payRegi 方法进行挂号费用支付操作
        Boolean bo = this.orderService.payRegi(oId);
        if (bo) {
            return ResponseData.success("挂号费用支付成功");  // 返回挂号费用支付成功的响应
        }
        return ResponseData.fail("挂号费用支付失败");  // 返回挂号费用支付失败的响应
    }

}
